home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / WILD16.PAK / MATHERR.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  6KB  |  153 lines
  1. /*------------------------------------------------------------------------
  2.  * filename - matherr.c
  3.  *
  4.  * function(s)
  5.  *        _matherr - user-modifiable math error handler
  6.  *-----------------------------------------------------------------------*/
  7.  
  8. /*
  9.  *      C/C++ Run Time Library - Version 8.0
  10.  *
  11.  *      Copyright (c) 1987, 1997 by Borland International
  12.  *      All Rights Reserved.
  13.  *
  14.  */
  15. /* $Revision:   8.2  $        */
  16.  
  17.  
  18. #include <math.h>
  19.  
  20. #ifdef _Windows
  21. #include <_win.h>
  22. #endif
  23.  
  24. #ifdef  UNIX_matherr
  25. #include <stdio.h>
  26. #include <process.h>
  27.  
  28. char *whyS [] =
  29. {
  30.     "argument domain error",
  31.     "argument singularity ",
  32.     "overflow range error ",
  33.     "underflow range error",
  34.     "total loss of significance",
  35.     "partial loss of significance"
  36. };
  37.  
  38. /*------------------------------------------------------------------------*
  39.  
  40. Name            _matherr - user-modifiable math error handler
  41.  
  42. Usage           #include <math.h>
  43.                 int _matherr(struct exception *e);
  44.  
  45. Prototype in    math.h
  46.  
  47. Description     When  exceptions are  detected in  the math  library then a
  48.                 call is made  to  _matherr()  with all the available
  49.                 information.
  50.  
  51.                 That function does very little, except to map the exception
  52.                 "why"  into either  ERANGE or  EDOMAIN in  errno. Its  main
  53.                 purpose is  to act as  a focal point  for changes in  error
  54.                 handling.
  55.  
  56.                 For example,  if you were  writing a spreadsheet  you might
  57.                 replace  this function with one which pops up an error
  58.                 window explaining something like:
  59.  
  60.                         "log (-2.0) caused domain error, in cell J7"
  61.  
  62.                 and then longjmp() to a  reset state in the spreadsheet and
  63.                 await the next command from the user.
  64.  
  65.                 The default version  of Turbo C's _matherr routine masks
  66.                 underflow and precision errors; others errors are considered
  67.                 fatal.  It serves as a hook that you can replace when
  68.                 writing your own math error handling routine.
  69.  
  70.                 The rationale for masking underflow and precision errors
  71.                 is that these are not errors according to the ANSI C spec.
  72.                 Consequently, you will get
  73.                         exp(-1000) = 0
  74.                         sin(1e100) = NAN
  75.                 without any error or warning, even though there is a total
  76.                 loss of precision in both cases.  You can trap these errors
  77.                 by modifying _matherr.
  78.  
  79.                 The possible errors are
  80.                         DOMAIN, SING, OVERFLOW, UNDERFLOW, TLOSS, PLOSS
  81.                 and listed in <math.h>.  As explained above, UNDERFLOW and
  82.                 TLOSS are masked by the default _matherr.  PLOSS is not
  83.                 supported by TC and is not generated by any library functions.
  84.                 The remaining errors, DOMAIN, SING, and OVERFLOW, are fatal
  85.                 with the default _matherr.
  86.  
  87.                 You  can  modify  _matherr  to  be  a  custom error handling
  88.                 routine (such as one that catches and resolves certain type
  89.                 of  errors); the  modified _matherr  should return  0 if  it
  90.                 failed to resolve  the error, or non-zero if  the error was
  91.                 resolved. When _matherr returns non-zero, no  error message
  92.                 is printed, and errno is not changed.
  93.  
  94.                 The  important thing  is  that  we  don't  know what error
  95.                 handling you want, but you are assured that all errors will
  96.                 arrive at  _matherr() with all  the information you  need to
  97.                 design a custom format.
  98.  
  99.                 We  do not  ship as  standard the  function named _matherr()
  100.                 which may be  familiar to UNIX users, since  the ANSI x3j11
  101.                 draft specifies  an incompatible style. This  version is as
  102.                 close as we could get  without breaking the ANSI rules. You
  103.                 can, however, convert this version to the UNIX style if you
  104.                 prefer. The necessary code is included but switched off.
  105.  
  106. Return value    The default return  value for _matherr is simply  0.
  107.                 _matherr can also modify  e->retval, which propagates through
  108.                 _matherr back to the original caller.
  109.  
  110.                 When _matherr returns 0, (indicating that it was not able to
  111.                 resolve the error) __matherr sets  errno and prints an error
  112.                 message.
  113.  
  114.                 When _matherr returns non-zero, (indicating that it was able
  115.                 to resolve the error) errno is not set and no messages are
  116.                 printed.
  117.  
  118. *-------------------------------------------------------------------------*/
  119. int _FARFUNC _matherr (struct exception *e)
  120. {
  121. #ifdef _Windows
  122.     char errMsg[ 80 ];
  123.     sprintf (errMsg,
  124.         "%s (%8g,%8g): %s\n", e->name, e->arg1, e->arg2, whyS [e->type - 1]);
  125.     _errorExitBox( errMsg, 1 );
  126. #else
  127.     fprintf (stderr,
  128.         "%s (%8g,%8g): %s\n", e->name, e->arg1, e->arg2, whyS [e->type - 1]);
  129.     exit (1);
  130. #endif
  131. }
  132. #else
  133.  
  134. int _FARFUNC _matherr(struct exception *e)
  135. {
  136.         if (e->type == UNDERFLOW)
  137.         {
  138.                 /* flush underflow to 0 */
  139.                 e->retval = 0;
  140.                 return 1;
  141.         }
  142.         if (e->type == TLOSS)
  143.         {
  144.                 /* total loss of precision, but ignore the problem */
  145.                 return 1;
  146.         }
  147.         /* all other errors are fatal */
  148.         return 0;
  149. }
  150.  
  151.  
  152. #endif
  153.